package com.heima.wemedia.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.injector.methods.SelectList;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heima.common.constants.NewsAutoScanConstants;
import com.heima.common.constants.WemediaContants;
import com.heima.common.constants.WmNewsMessageConstants;
import com.heima.common.exception.CostomException;
import com.heima.common.fastdfs.FastDFSClient;
import com.heima.model.common.dtos.PageResponseResult;
import com.heima.model.common.dtos.ResponseResult;
import com.heima.model.common.enums.AppHttpCodeEnum;


import com.heima.model.wemedia.dtos.NewsAuthDto;
import com.heima.model.wemedia.dtos.WmNewsDto;
import com.heima.model.wemedia.dtos.WmNewsPageReqDto;

import com.heima.model.wemedia.pojos.WmMaterial;
import com.heima.model.wemedia.pojos.WmNews;
import com.heima.model.wemedia.pojos.WmNewsMaterial;
import com.heima.model.wemedia.pojos.WmUser;
import com.heima.model.wemedia.vos.WmNewsVo;
import com.heima.utils.threadlocal.WmThreadLocalUtils;
import com.heima.wemedia.mapper.WmMaterialMapper;
import com.heima.wemedia.mapper.WmNewsMapper;
import com.heima.wemedia.mapper.WmNewsMaterialMapper;
import com.heima.wemedia.service.WmNewsService;
import com.heima.wemedia.service.WmUserService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
@Transactional
public class WmNewsServiceImpl extends ServiceImpl<WmNewsMapper, WmNews> implements WmNewsService {

    @Value("${fdfs.url}")
    private String fileServerUrl;

    @Autowired
    private WmNewsMaterialMapper wmNewsMaterialMapper;

    @Autowired
    private WmMaterialMapper wmMaterialMapper;

    @Autowired
    private WmNewsMapper wmNewsMapper;

    @Autowired
    WmUserService wmUserService;

    @Autowired
    KafkaTemplate kafkaTemplate;


    @Override
    public ResponseResult findList(NewsAuthDto dto) {
        dto.checkParam();
        Integer page = dto.getPage();
        dto.setPage((dto.getPage() - 1) * dto.getSize());
        if (dto.getTitle()!=null&&dto.getTitle()!=""){
            dto.setTitle("%"+dto.getTitle()+"%");
        }
        List<WmNewsVo> wmNewsList = wmNewsMapper.findList(dto);
        Integer count = wmNewsMapper.findCount(dto);
        PageResponseResult pageResult = new PageResponseResult(page, dto.getSize(), count);
        pageResult.setData(wmNewsList);
        pageResult.setHost(fileServerUrl);
        return pageResult;
    }

    /**
     * 文章人工审核通过 或者失败 修改文章状态
     * @param dto
     * @return
     */
    @Override
    public ResponseResult updateNewsStatus(NewsAuthDto dto) {
        if (dto == null ||dto.getId()==null){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        Integer id = dto.getId();
        WmNews wmNews = getById(id);
        if (wmNews==null){
            return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST,"文章不存在");
        }
        wmNews.setStatus(dto.getStatus());
        if (StringUtils.isNotBlank(dto.getMsg())){
            wmNews.setReason(dto.getMsg());
        }
        updateById(wmNews);
        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }

    @Override
    public ResponseResult findWmNewsVo(Integer id) {

        if (id == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        WmNews one = getById(id);
        if(one == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST);
        }
        WmUser user = wmUserService.getById(one.getUserId());
        if (user == null){
            return ResponseResult.errorResult(AppHttpCodeEnum.DATA_NOT_EXIST);
        }
        WmNewsVo wmNewsVo = new WmNewsVo();
        BeanUtils.copyProperties(one,wmNewsVo);
        wmNewsVo.setAuthorName(user.getName());
        ResponseResult responseResult = ResponseResult.okResult(wmNewsVo);
        responseResult.setHost(fileServerUrl);
        return responseResult;
    }

    /**
     * 查询数据库中的文章  状态为8（待发布）和状态为4（人工审核通过）并且发布时间小于等于当前时间的文章id
     * 用于xxl-Job定时执行发布这些文章
     *
     * @return
     */
    @Override
    public List<Integer> findRelease() {
        List<WmNews> list = list(Wrappers.<WmNews>lambdaQuery().in(WmNews::getStatus, (short) 8, (short) 4).le(WmNews::getPublishTime, new Date())
                .select(WmNews::getId));
        List<Integer> ids = list.stream().map(WmNews::getId).collect(Collectors.toList());
        return ids;
    }

    /**
     * 修改文章上下架状态
     *
     * @param dto
     * @return
     */
    @Override
    public ResponseResult downOrUp(WmNewsDto dto) {
        if (dto == null || dto.getId() == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        WmNews one = getOne(Wrappers.<WmNews>lambdaQuery().eq(WmNews::getId, dto.getId())
                .eq(WmNews::getUserId, WmThreadLocalUtils.getUser().getId()));
        if (one == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "文章不存在");
        }
        if (one.getStatus() == null || !one.getStatus().equals((short) 9)) {
            return ResponseResult.errorResult(AppHttpCodeEnum.ERROR, "文章没有发布，不能上下架！");
        }

        if (dto.getEnable() != null && dto.getEnable() > -1 && dto.getEnable() < 2) {
            one.setEnable(dto.getEnable());
            updateById(one);
            //利用kafka发送消息 将文章的上下架同步到app端的文章上下架状态
            kafkaTemplate.send(WmNewsMessageConstants.WM_NEWS_UP_OR_DOWN_TOPIC,JSON.toJSONString(one));
            return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
        }

        return ResponseResult.errorResult(AppHttpCodeEnum.ERROR);
    }

    /**
     * 根据id查询文章
     *
     * @param id
     * @return
     */
    @Override
    public ResponseResult findWmNewsById(Integer id) {
        //检查参数
        if (id == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        WmNews one = getOne(Wrappers.<WmNews>lambdaQuery().eq(WmNews::getId, id)
                .eq(WmNews::getUserId, WmThreadLocalUtils.getUser().getId()));
        if (one == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "文章不存在");
        }
        ResponseResult responseResult = ResponseResult.okResult(one);
        responseResult.setHost(fileServerUrl);
        return responseResult;
    }


    /**
     * 根据id删除文章
     *
     * @param id
     * @return
     */
    @Override
    public ResponseResult delNews(Integer id) {
        if (id == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }
        WmNews one = getOne(Wrappers.<WmNews>lambdaQuery().eq(WmNews::getId, id)
                .eq(WmNews::getUserId, WmThreadLocalUtils.getUser().getId()));
        if (one == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "文章不存在");
        }
        //如果文章已经发布（Status：9）并且上架（Enable：1） 不能删除
        if (one.getStatus().equals((short) 9) && one.getEnable().equals((short) 1)) {
            return ResponseResult.errorResult(AppHttpCodeEnum.NO_OPERATOR_AUTH, "文章已发布并且上架，不能删除！");
        }

        wmNewsMaterialMapper.delete(Wrappers.<WmNewsMaterial>lambdaQuery()
                .eq(WmNewsMaterial::getNewsId, id));
        removeById(id);
        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }


    @Override
    public ResponseResult saveNews(WmNewsDto dto) {
        //检查参数
        if (dto == null || StringUtils.isBlank(dto.getContent())) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        //将前端传来的数据封装为 对象 （属性名必须对应）
        WmNews wmNews = new WmNews();
        BeanUtils.copyProperties(dto, wmNews);

        //数据库的type字段类型在设置时设置的不能存负值 所以如果是-1的话 先设置为null 后面再修改
        if (dto.getType().equals((short) -1)) {
            wmNews.setType(null);
        }

        //getImages的内容可能是 ["a.jpg","b.jpg","c.jpg"]
        if (dto.getImages() != null && dto.getImages().size() > 0) {
            // 把集合转为字符串并把中括号去掉 如果有前缀 前缀也去掉 获得的字符串imageStr "a.jpg,b.jpg,c.jpg" 就可以存入了
            String imageStr = dto.getImages().toString().replace("[", "").replace("]", "")
                    .replace(fileServerUrl, "").replace(" ", "");
            wmNews.setImages(imageStr);
            //// 这个方法是 传入一个集合 将集合转为字符串 并以 , 分隔 在这中括号就不用处理了 因为他是集合里面的 我们需要把该清除的内容
            ////清除以下 就可以了  两个方法任选其一
            //String imageStr = StringUtils.join(dto.getImages().stream().map(x -> x.replace(fileServerUrl, "")
            //.replace(" ", "")).collect(Collectors.toList()), ",");
        }

        //这里wmnews的属性基本都有了 如果选了封面 那封面也有了 如果没选 后面images和type也会补上
        savewmNews(wmNews);

        //从文章内容中获取图片路径
        List<String> newsContentImages = getNewsContentImage(dto.getContent());


        if (dto.getStatus().equals((short) 1) && newsContentImages.size() > 0) {
            //如果文章选择的是提交 并且文章内容中有图片 我就保存中间表
            saveNewsMaterial4ContentImages(newsContentImages, wmNews.getId());
        }

        if (dto.getStatus().equals((short) 1)) {
            //如果文章选择的是提交的话 我进来 保存封面图片与文章的关系
            //不要判断如果images里面有没有东西 因为就算没有东西 有可能选择的是自动选择 也要进去保存
            saveNewsMaterial4Images(newsContentImages, wmNews, dto);
        }

        if (dto.getStatus().equals((short) 0) && dto.getType().equals((short) -1)) {
            //如果选择的是草稿 但是封面为自动选择 就走这个方法 把文章的images和type设置进去
            editNewsTypeAndImages(newsContentImages, wmNews);
        }

        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
    }

    /**
     * 保存封面素材与文章的关系 并修改文章表的type和images
     *
     * @param newsContentImages
     * @param wmNews
     * @param dto
     */
    private void saveNewsMaterial4Images(List<String> newsContentImages, WmNews wmNews, WmNewsDto dto) {
        List<String> images = dto.getImages();
        if (dto.getType().equals((short) -1)) {
            images = editNewsTypeAndImages(newsContentImages, wmNews);
        }
        if (images.size() > 0 && images != null) {
            //这个方法是 保存封面与文章的关系
            saveNewsMaterial4images(images, wmNews.getId());
        }
    }

    /**
     * 设置文章images和type 并返回images
     *
     * @param newsContentImages
     * @param wmNews
     * @return
     */
    private List<String> editNewsTypeAndImages(List<String> newsContentImages, WmNews wmNews) {
        List<String> images = new ArrayList<>();
        //这个方法主要是把文章的type和images准备好 设置进去
        if (newsContentImages.size() > 2) {
            wmNews.setType((short) 3);
            images = newsContentImages.stream().limit(3).collect(Collectors.toList());
        } else if (newsContentImages.size() > 0 && newsContentImages.size() <= 2) {
            wmNews.setType((short) 1);
            images = newsContentImages.stream().limit(1).collect(Collectors.toList());
        } else {
            wmNews.setImages("");
            wmNews.setType((short) 0);
        }
        if (images.size() > 0 && images != null) {
            //如果images不等于空的话 再插入中间表 这里replace替换的时候不用替换 前缀 因为肯定没有前缀 如果是封面图片本来就有的话
            //才有前缀 而本来就有的话 tpye肯定不是-1 也不会进入到这里面来 而进来肯定是没东西 并且newsContentImages里面
            // 是已经去除过前缀的 所以不用去除
            String imageStr = images.toString().replace("[", "").replace("]", "");
            wmNews.setImages(imageStr);
        }
        updateById(wmNews); //这样的话 文章表的type和images就补上了
        return images;
    }


    /**
     * 这个方法是 保存内容图片与文章的关系
     *
     * @param images
     * @param id
     */
    private void saveNewsMaterial4ContentImages(List<String> newsContentImages, Integer id) {

        List<WmMaterial> contentImages = wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery()
                .in(WmMaterial::getUrl, newsContentImages)
                .eq(WmMaterial::getUserId, WmThreadLocalUtils.getUser().getId()));
        //如果选择的内容图片 数据库没有查到 报错
        if (newsContentImages.size() != contentImages.size()) {
            throw new CostomException(ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "素材不存在或缺失！"));
        }

        //获取素材id
        List<Integer> ids = getMaterialID(contentImages);
        wmNewsMaterialMapper.saveRelationsByContent(ids, id, 0);
    }


    /**
     * 这个方法是 保存封面与文章的关系
     *
     * @param images
     * @param id
     */
    private void saveNewsMaterial4images(List<String> images, Integer id) {
        //根据选择的封面图片路径 去除前缀 因为如果是从内容中拿到的图片 没有前缀 但是前端本来就有选择封面的话 肯定是有前缀的
        List<String> imageurl = getImageUrl(images);

        List<WmMaterial> Images = wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery()
                .in(WmMaterial::getUrl, imageurl)
                .eq(WmMaterial::getUserId, WmThreadLocalUtils.getUser().getId()));

        //如果选择的封面 数据库中没有查到 报错
        if (imageurl.size() != images.size()) {
            throw new CostomException(ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID, "素材不存在或缺失！"));
        }

        //获取素材id
        List<Integer> ids = getMaterialID(Images);
        wmNewsMaterialMapper.saveRelationsByContent(ids, id, 1);
    }

    /**
     * 获取素材的id
     *
     * @param images
     * @return
     */
    private List<Integer> getMaterialID(List<WmMaterial> images) {
        ArrayList<Integer> ids = new ArrayList<>();
        for (WmMaterial image : images) {
            Integer id = image.getId();
            ids.add(id);
        }
        return ids;
    }

    /**
     * 从封面图片中获取图片路径 (去除前缀)
     *
     * @param images
     * @return
     */
    private List<String> getImageUrl(List<String> images) {
        ArrayList<String> imagesUrl = new ArrayList<>();
        for (String image : images) {
            image = image.replace(fileServerUrl, "");
            imagesUrl.add(image);
        }
        return imagesUrl;
    }


    /**
     * 从文章内容中获取图片路径
     *
     * @param content
     * @return
     */
    private List<String> getNewsContentImage(String content) {
        List<Map> maps = JSON.parseArray(content, Map.class);
        ArrayList<String> images = new ArrayList<>();
        for (Map map : maps) {
            if (map.get("type").equals("image")) {
                String imageUrl = (String) map.get("value");
                imageUrl = imageUrl.replace(fileServerUrl, "");
                images.add(imageUrl);
            }
        }
        return images;
    }


    /**
     * 保存或修改文章
     *
     * @param wmNews
     */
    private void savewmNews(WmNews wmNews) {
        wmNews.setUserId(WmThreadLocalUtils.getUser().getId());
        wmNews.setSubmitedTime(new Date());
        wmNews.setEnable((short) 1);
        boolean flag = false;
        if (wmNews.getId() == null) {
            wmNews.setCreatedTime(new Date());
            flag = save(wmNews);
        } else {
            wmNewsMaterialMapper.delete(Wrappers.<WmNewsMaterial>lambdaQuery().eq(WmNewsMaterial::getNewsId, wmNews.getId()));
            flag = updateById(wmNews);
        }

        if (flag) {
            kafkaTemplate.send(NewsAutoScanConstants.WM_NEWS_AUTO_SCAN_TOPIC, JSON.toJSONString(wmNews.getId()));
        }
    }


    /**
     *
     *- 该功能为保存、修改（是否有id）、保存草稿的共有方法
     * - 如果有id修改文章，先删除所有素材关联关系
     * - 如果没有id，保存文章
     * - 关联内容中的图片与素材的关系
     * - 关联封面中的图片与素材的关系
     *   - 封面图片如果选择是自动需要从内容中截图图片做为封面图片
     *     截取规则为：内容图片的个数小于等于2  则为单图截图一张图，内容图片大于2，则为多图，截图三张图，内容中没有图片，则为无图
     * @param dto
     * @return
     */
//    @Override
//    public ResponseResult saveNews(WmNewsDto dto) {
//
//        if (dto == null||StringUtils.isBlank(dto.getContent())){
//            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
//        }
//
//        WmNews wmNews = new WmNews();
//        BeanUtils.copyProperties(dto,wmNews);
//
//        if (dto.getType().equals((short)-1)){
//            wmNews.setType(null);
//        }
//
//            //这个是封面图片的id值
//        List<Integer> wmMaterialIDs2 =null;
//
//        if (dto.getImages().size()>0){
//            String images = dto.getImages().toString();
//            String replace = images.replace("[", "")
//                    .replace("]", "")
//                    .replace(" ", "")
//                    .replace(fileServerUrl,"");
////            for (String image : images) {
////                if (image!=null){
////                    stringBuilder.append(image);
////                }
////            }
//            wmNews.setImages(replace);
//
//            ArrayList<String> strings = new ArrayList<>();
//            List<String> images1 = dto.getImages();
//            for (String s : images1) {
//                String replace1 = s.replace(fileServerUrl, "");
//                strings.add(replace1);
//            }
//           wmMaterialIDs2 = getWmMaterialIDs(strings);
//        }
//
//        wmNews.setUserId(WmThreadLocalUtils.getUser().getId());
//        //无论添加还是修改 默认为上架 也就是1
//        wmNews.setEnable((short) 1);
//        //无论添加还是修改  提交时间都要重置
//        wmNews.setSubmitedTime(new Date());
//        //执行方法 保存或修改
//        saveOrEditWmNews(wmNews);
//
//        //走到这 文章表已经有了 中间表还没有 而且文章的type类型 需要改变
//        if (dto.getStatus().equals((short)1)&&wmMaterialIDs2.size()>0){
//
//            wmNewsMaterialMapper.saveRelationsByContent(wmMaterialIDs2,wmNews.getId(),1);
//        }
//
//
//        //获得文章内容中的所有图片路径
//        List<String> newsContentImages = getNewsContentImages(wmNews);
//        if (dto.getImages().size()>0){}
//
//        //获得文章内容中的根据图片路径 到数据库里查询出来的所有图片路径
//        List<String> wmMaterialUrl = getWmMaterialUrl(newsContentImages);
//
//        if (newsContentImages.size()!=wmMaterialUrl.size()){
//            //如果前端选的图片数量 和实际去数据库里查出来的图片数量不一致 代表素材没有了 或者被人删了 肯定不行
//            throw new CostomException(ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID,"素材不存在或缺失"));
//        }
//
//        //获得文章内容中所有图片的ID
//        //NewsContentImages为文章内容中所有的图片的ID值
//        List<Integer> wmMaterialIDs = getWmMaterialIDs(newsContentImages);
//
//
//        //如果获得的图片数量不等于0 并且文章是要提交的话  就进入方法 插入中间表
//        if (wmMaterialIDs.size()>0&&dto.getStatus().equals((short)1)){
//            //插入中间表
//            // wmMaterialIDs是图片素材id
//            // wmNews.getId()是文章的id 在添加文章表的主键自动回填了 如果修改文章表的话 id是已经存在的 所以这时候id肯定有
//            // type:0  如果是内容引用的话 是0   主图封面引用的话 是1
//            wmNewsMaterialMapper.saveRelationsByContent(wmMaterialIDs,wmNews.getId(),0);
//        }
//        //此时已经把 文章内容引用的图片 插入中间表了
//
//        //如果文章所选的封面为自动 也就是-1  进去
//        if (dto.getType().equals((short)-1)){
//            //TODO:此方法主要作用是：
//            //    1.将文章内容中的图片url拿出来 根据自动选择规则 挑选出图片 然后插入中间表
//            //    2.判断数量 决定出文章的type 然后修改文章的type值
//            //    3.拿到封面图片的路径 存入文章的images里面
//
//            ArrayList<Integer> ids = new ArrayList<>();
//            if (wmMaterialIDs.size()>2){
//                //如果文章内容中图片数量大于2的话 则是多图 取3张图片作为封面图片
//                for (int i = 0; i <=2 ; i++) {
//                    Integer wmMaterID = wmMaterialIDs.get(i);
//                    ids.add(wmMaterID);
//                }
//                //这样的话 ids里面就有了3张图片的id值
//                wmNews.setType((short)3);
//                String url0 = wmMaterialUrl.get(0);
//                String url1 = wmMaterialUrl.get(1);
//                String url2 = wmMaterialUrl.get(2);
//                String images = url0+","+url1+","+url2;
//                wmNews.setImages(images);
//                updateById(wmNews);
//            }else if (wmMaterialIDs.size()>0&&wmMaterialIDs.size()<=2){
//                Integer id = wmMaterialIDs.get(0);
//                ids.add(id);
//                //这样的话 ids里面就有了1张图片的id值
//                wmNews.setType((short)1);
//                String url = wmMaterialUrl.get(0);
//                wmNews.setImages(url);
//                updateById(wmNews);
//            }else {
//                wmNews.setType((short)0);
//                updateById(wmNews);
//            }
//
//            //此时 如果ids里面 大于0的话 我再插入中间表 如果小于或等于0的话 代表无图文章 就不插入了
//            //type：1   为主图封面引用
//            if (ids.size()>0&&dto.getStatus().equals((short)1)){
//                wmNewsMaterialMapper.saveRelationsByContent(ids,wmNews.getId(),1);
//            }
//        }
//
//
//        //此时 文章表已经插入
//        // 文章内容图片也已经插入到中间表
//        // 文章内容图片作为封面也已经插入中间表
//        // 文章表的type也已经设置为对应的类型  image也赋上了对应的值
//
//        return ResponseResult.okResult(AppHttpCodeEnum.SUCCESS);
//    }
//
//    /**
//     * 根据前端传入的文章内容 获得所有文章内容图片里的url路径
//     * @param newsContentImages
//     * @return
//     */
//    private List<String> getWmMaterialUrl(List<String> newsContentImages) {
//        ArrayList<String> wmMaterUrls = new ArrayList<>();
//        List<WmMaterial> wmMaterials = wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery()
//                .in(WmMaterial::getUrl, newsContentImages)
//                .eq(WmMaterial::getUserId,WmThreadLocalUtils.getUser().getId()));
//        for (WmMaterial wmMaterial : wmMaterials) {
//            String url = wmMaterial.getUrl();
//            wmMaterUrls.add(url);
//        }
//        return wmMaterUrls;
//    }
//
//
//    /**
//     * 根据前端传来的文章内容中所选图片的url路径 获取到对应图片素材的id值 用与插入中间表
//     * @param newsContentImages
//     * @return
//     */
//    private List<Integer> getWmMaterialIDs(List<String> newsContentImages) {
//        ArrayList<Integer> ids = new ArrayList<>();
//        //根据图片的url和自媒体的id去查出来所有的图片素材对象
//        List<WmMaterial> wmMaterials = wmMaterialMapper.selectList(Wrappers.<WmMaterial>lambdaQuery()
//                .in(WmMaterial::getUrl, newsContentImages)
//                .eq(WmMaterial::getUserId,WmThreadLocalUtils.getUser().getId()));
//
//        for (WmMaterial wmMaterial : wmMaterials) {
//            Integer id = wmMaterial.getId();
//            ids.add(id);
//        }
//            return ids;
//    }
//
//
//    /**
//     * 获得文章内容中的所有图片路径
//     * @param wmNews
//     * @return
//     */
//    private List<String> getNewsContentImages(WmNews wmNews) {
//        ArrayList<String> imagesList = new ArrayList<>();
//        String content = wmNews.getContent();
//        List<Map> maps = JSON.parseArray(content, Map.class);
//        for (Map map : maps) {
//            if (map.get("type").equals("image")){
//                String value = (String)map.get("value");
//                String imageUrl = value.replace(fileServerUrl, "");
//                imagesList.add(imageUrl);
//            }
//        }
//       return imagesList;
//    }
//
//
//
//    /**
//     * 保存 或修改（先删除中间表）文章表
//     * @param wmNews
//     */
//    private void saveOrEditWmNews(WmNews wmNews) {
//        if (wmNews.getId() == null){
//            //文章id为空 添加
//            //设置创建时间
//            wmNews.setCreatedTime(new Date());
//            //先保存 至于文章的type类型 也就是文章封面是多图还是单图还是无图 后面再修改 根据dto的type来修改
//            save(wmNews);
//
//        }else {
//            //文章id不为空 修改
//            //修改前先删除中间表 把属于这篇文章的中间表全删除    在后面再重新添加中间表
//            wmNewsMaterialMapper.delete(Wrappers.<WmNewsMaterial>lambdaQuery().eq(WmNewsMaterial::getNewsId,wmNews.getId()));
//            updateById(wmNews);
//        }
//    }
//


    /**
     * 查询自媒体文章列表（网页上是 内容列表）
     *
     * @param dto
     * @return
     */
    @Override
    public ResponseResult findAll(WmNewsPageReqDto dto) {

        //现在就是要 把自媒体人自己上传的文章 给查出来

        //判断参数
        if (dto == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.PARAM_INVALID);
        }

        dto.checkParam();

        IPage pageParam = new Page(dto.getPage(), dto.getSize());
        LambdaQueryWrapper<WmNews> lambdaQuery = new LambdaQueryWrapper<>();

        //拼接参数
        if (dto.getStatus() != null) {
            lambdaQuery.eq(WmNews::getStatus, dto.getStatus());
        }

        if (dto.getBeginPubDate() != null && dto.getEndPubDate() != null) {
            lambdaQuery.between(WmNews::getPublishTime, dto.getBeginPubDate(), dto.getEndPubDate());
        }

        if (dto.getChannelId() != null) {
            lambdaQuery.eq(WmNews::getChannelId, dto.getChannelId());
        }

        if (dto.getKeyword() != null) {
            //如果输入的关键字 那关键字是按照标题 去模糊查找的
            lambdaQuery.like(WmNews::getTitle, dto.getKeyword());
        }

        WmUser user = WmThreadLocalUtils.getUser();
        if (user == null) {
            return ResponseResult.errorResult(AppHttpCodeEnum.NEED_LOGIN);
        }

        lambdaQuery.eq(WmNews::getUserId, user.getId());

        lambdaQuery.orderByDesc(WmNews::getCreatedTime);

        //进行查询 获取数据
        IPage pageResult = page(pageParam, lambdaQuery);

        //返回数据之前 给responseResult加上IP地址 可能会直接映射到里面图片的 地址上面 会加在图片地址的前缀部分 就可以显示出来了
        PageResponseResult pageResponseResult = new PageResponseResult(dto.getPage(), dto.getSize(), (int) pageResult.getTotal());
        pageResponseResult.setData(pageResult.getRecords());
        pageResponseResult.setHost(fileServerUrl);

        return pageResponseResult;
    }
}